// 导入标准库
use std::fs;
use std::io::Write;
use std::path::Path;
use std::sync::Arc;
use std::thread;
use std::time::Duration;
use std::process::Command;
use std::string::ToString;

use eframe::{egui, NativeOptions}; use eframe::egui::{pos2, vec2, Color32, Rect, TextStyle};
use serde::{Deserialize, Serialize};
use tokio::runtime::Runtime;
use log::{info, error};

// 导入内核配置模块
mod kernel_config;
use kernel_config::{KernelConfig, SystemConfig};

// 导入构建和运行模块
mod build_run;
mod visual_programming;
use build_run::{build_chym, run_chym, check_chym_environment, BuildRunResult};
use visual_programming::VisualProgram;



// 应用程序状态
/// 应用标签页
#[derive(Clone)]
enum AppTab {
    KernelConfig,
    VisualProgramming,
    RealTimePreview,
}

#[derive(Clone)]
struct OsDesignStudio {
    config: SystemConfig,
    chym_path: String,
    output_log: String,
    is_building: bool,
    is_running: bool,
    /// 当前活动的标签页
    active_tab: AppTab,
    /// 可视化程序
    visual_program: VisualProgram,
}

impl Default for OsDesignStudio {
    fn default() -> Self {
        Self {
            config: SystemConfig {
                kernels: vec![
                    KernelConfig { kernel_type: "main".to_string(), cpu_cores: 2, memory_mb: 512 },
                    KernelConfig { kernel_type: "app1".to_string(), cpu_cores: 1, memory_mb: 256 },
                    KernelConfig { kernel_type: "app2".to_string(), cpu_cores: 1, memory_mb: 256 },
                ],
            },
            chym_path: "D:\\PROJECT\\chym".to_string(),
            output_log: String::new(),
            is_building: false,
            is_running: false,
            active_tab: AppTab::KernelConfig,
            visual_program: VisualProgram::default(),
        }
    }
}

impl eframe::App for OsDesignStudio {
    fn update(&mut self, ctx: &egui::Context, _frame: &mut eframe::Frame) {
        egui::TopBottomPanel::top("top_panel").show(ctx, |ui| {
            ui.heading("OS Design Studio - Chym 内核可视化编程工具");
            
            // 标签页切换
            ui.horizontal(|ui| {
                if ui.selectable_label(matches!(self.active_tab, AppTab::KernelConfig), "内核配置").clicked() {
                    self.active_tab = AppTab::KernelConfig;
                }
                if ui.selectable_label(matches!(self.active_tab, AppTab::VisualProgramming), "可视化编程").clicked() {
                    self.active_tab = AppTab::VisualProgramming;
                }
                if ui.selectable_label(matches!(self.active_tab, AppTab::RealTimePreview), "实时预览").clicked() {
                    self.active_tab = AppTab::RealTimePreview;
                }
            });
        });

        // 根据当前标签页显示不同内容
        match self.active_tab {
            AppTab::KernelConfig => {
                egui::SidePanel::left("left_panel").show(ctx, |ui| {
                    ui.vertical(|ui| {
                        ui.heading("内核配置");
                        
                        // Chym 路径配置
                        ui.group(|ui| {
                            ui.label("Chym 项目路径");
                            ui.text_edit_singleline(&mut self.chym_path);
                            if ui.button("浏览").clicked() {
                                // 这里可以添加文件选择对话框（需要额外依赖）
                            }
                        });

                        // 内核配置列表
                        ui.group(|ui| {
                            ui.label("内核列表");
                            
                            for (i, kernel) in self.config.kernels.iter_mut().enumerate() {
                                ui.collapsing(format!("内核 {}", i + 1), |ui| {
                                    ui.horizontal(|ui| {
                                        ui.label("类型:");
                                        ui.text_edit_singleline(&mut kernel.kernel_type);
                                    });
                                    
                                    ui.horizontal(|ui| {
                                        ui.label("CPU核心数:");
                                        ui.add(egui::DragValue::new(&mut kernel.cpu_cores).range(1..=16));
                                    });
                                    
                                    ui.horizontal(|ui| {
                                        ui.label("内存 (MB):");
                                        ui.add(egui::DragValue::new(&mut kernel.memory_mb).range(256..=8192).speed(256.0));
                                    });
                                });
                            }
                            
                            if ui.button("添加内核").clicked() {
                                self.config.kernels.push(KernelConfig {
                                    kernel_type: format!("kernel{}", self.config.kernels.len() + 1),
                                    cpu_cores: 1,
                                    memory_mb: 256,
                                });
                            }
                            
                            if ui.button("移除内核").clicked() && !self.config.kernels.is_empty() {
                                self.config.kernels.pop();
                            }
                        });

                        // 构建和运行按钮
                        ui.group(|ui| {
                            ui.horizontal(|ui| {
                                let build_btn = ui.button("构建内核");
                                let run_btn = ui.button("运行内核");
                                
                                if build_btn.clicked() && !self.is_building && !self.is_running {
                                    self.is_building = true;
                                    self.output_log.clear();
                                    
                                    // 保存配置文件
                                    self.save_config();
                                    
                                    // 执行构建命令
                                    let app = self.clone();
                                    std::thread::spawn(move || {
                                        let rt = Runtime::new().unwrap();
                                        rt.block_on(app.build_kernel());
                                    });
                                }
                                
                                if run_btn.clicked() && !self.is_running && !self.is_building {
                                    self.is_running = true;
                                    self.output_log.clear();
                                    
                                    // 保存配置文件
                                    self.save_config();
                                    
                                    // 执行运行命令
                                    let app = self.clone();
                                    std::thread::spawn(move || {
                                        let rt = Runtime::new().unwrap();
                                        rt.block_on(app.run_kernel());
                                    });
                                }
                            });
                        });
                    });
                });

                egui::CentralPanel::default().show(ctx, |ui| {
                    ui.heading("构建日志");
                    
                    egui::ScrollArea::vertical().show(ui, |ui| {
                        ui.monospace(&self.output_log);
                    });
                    
                    // 清除日志按钮
                    if ui.button("清除日志").clicked() {
                        self.output_log = "".to_string();
                    }
                });
            },
            AppTab::VisualProgramming => {
                egui::SidePanel::left("visual_toolbar").show(ctx, |ui| {
                    ui.vertical(|ui| {
                        ui.heading("节点工具栏");
                        
                        // 添加节点按钮组
                        if ui.button("内核配置节点").clicked() {
                            self.visual_program.create_node(visual_programming::NodeType::KernelConfig, (100.0, 100.0));
                        }
                        
                        if ui.button("启动函数节点").clicked() {
                            self.visual_program.create_node(visual_programming::NodeType::BootFunction, (100.0, 200.0));
                        }
                        
                        if ui.button("日志函数节点").clicked() {
                            self.visual_program.create_node(visual_programming::NodeType::LogFunction, (100.0, 300.0));
                        }
                        
                        if ui.button("IO函数节点").clicked() {
                            self.visual_program.create_node(visual_programming::NodeType::IoFunction, (100.0, 400.0));
                        }
                        
                        ui.separator();
                        
                        // 节点操作按钮组
                        if ui.button("删除选中节点").clicked() {
                            if let Some(node_id) = self.visual_program.selected_node.clone() {
                                self.visual_program.delete_node(&node_id);
                            }
                        }
                        
                        if ui.button("生成Chym代码").clicked() {
                            let chym_code = self.visual_program.generate_chym_code();
                            self.output_log += &format!("\n生成的Chym代码:\n{}\n", chym_code);
                            
                            // 保存生成的代码到文件
                            let kernel_entry_path = std::path::Path::new(&self.chym_path).join("内核入口.chim");
                            std::fs::write(kernel_entry_path, chym_code).unwrap_or_else(|e| {
                                self.output_log += &format!("保存代码失败: {}\n", e);
                            });
                        }
                    });
                });

                egui::CentralPanel::default().show(ctx, |ui| {
                    ui.heading("可视化编程画布");
                    
                    // 创建可视化编程画布
                    let rect = ui.available_rect_before_wrap();
                    
                    // 阶段1：不可变绘制操作 - 只使用painter进行绘制，不修改ui或visual_program
                    {
                        let painter = ui.painter();
                        
                        // 绘制网格背景
                        self.visual_program.render_background(&painter, rect);
                        
                        // 绘制连接线
                        self.visual_program.render_connections(&painter);
                        
                        // 绘制节点（只读绘制）
                        let selected_node = self.visual_program.selected_node.clone();
                        for (node_id, node) in &self.visual_program.nodes {
                            let node_rect = Rect::from_min_size(
                                pos2(node.position.0, node.position.1),
                                vec2(200.0, 150.0)
                            );
                            
                            // 绘制节点背景（使用egui 0.33.2的rect方法，带边框）
                            painter.rect(
                                node_rect,
                                10.0,
                                eframe::egui::Color32::from_rgb(60, 60, 60),
                                eframe::egui::Stroke::new(2.0, if Some(node_id.to_string()) == selected_node {
                                    eframe::egui::Color32::WHITE
                                } else {
                                    eframe::egui::Color32::GRAY
                                }),
                                eframe::egui::StrokeKind::Inside
                            );
                            
                            // 绘制节点标题
                            painter.text(
                                node_rect.min + vec2(10.0, 30.0),
                                egui::Align2::LEFT_TOP,
                                &node.title,
                                TextStyle::Heading.resolve(ui.style()),
                                Color32::WHITE
                            );
                        }
                    }
                    
                    // 阶段2：用户交互处理 - 只修改visual_program，不使用painter
                    {
                        // 处理节点拖拽
                        let mut drag_offset = None;
                        let mut dragged_node = None;
                        
                        // 检查是否有节点被点击
                        for (node_id, node) in &self.visual_program.nodes {
                            let node_rect = Rect::from_min_size(
                                pos2(node.position.0, node.position.1),
                                vec2(200.0, 150.0)
                            );
                            
                            let response = ui.interact(node_rect, egui::Id::new(format!("node_{}", node_id)), egui::Sense::click_and_drag());
                            
                            if response.clicked() {
                                // 选择节点
                                self.visual_program.selected_node = Some(node_id.to_string());
                            }
                            
                            if response.dragged() {
                                dragged_node = Some(node_id.to_string());
                                drag_offset = Some(response.drag_delta());
                            }
                        }
                        
                        // 执行节点拖拽
                        if let (Some(node_id), Some(offset)) = (dragged_node, drag_offset) {
                            if let Some(node) = self.visual_program.nodes.get_mut(&node_id) {
                                node.position.0 += offset.x;
                                node.position.1 += offset.y;
                            }
                        }
                    }
                    
                    // 显示节点属性编辑面板
                    if let Some(node_id) = &self.visual_program.selected_node {
                        if let Some(node) = self.visual_program.nodes.get_mut(node_id) {
                            ui.separator();
                            ui.heading("节点属性");
                            
                            // 编辑节点标题
                            ui.text_edit_singleline(&mut node.title);
                            
                            // 编辑节点参数
                            for (key, value) in &mut node.data.parameters {
                                ui.horizontal(|ui| {
                                    ui.label(key);
                                    ui.text_edit_singleline(value);
                                });
                            }
                            
                            // 编辑代码模板
                            if let Some(template) = &mut node.data.code_template {
                                ui.label("代码模板");
                                ui.text_edit_multiline(template);
                            }
                        }
                    }
                });
            },
            AppTab::RealTimePreview => {
                egui::SidePanel::left("preview_side_panel").show(ctx, |ui| {
                    ui.vertical(|ui| {
                        ui.heading("实时预览与调试");
                        
                        // 调试控制按钮
                        ui.group(|ui| {
                            ui.heading("调试控制");
                            if ui.button("启动调试").clicked() {
                                // 启动调试功能
                                self.output_log.push_str("启动调试会话...\n");
                            }
                            if ui.button("暂停执行").clicked() {
                                // 暂停调试
                                self.output_log.push_str("调试执行已暂停...\n");
                            }
                            if ui.button("继续执行").clicked() {
                                // 继续调试
                                self.output_log.push_str("调试执行已继续...\n");
                            }
                            if ui.button("停止调试").clicked() {
                                // 停止调试
                                self.output_log.push_str("调试会话已结束...\n");
                            }
                        });
                        
                        ui.separator();
                        
                        // 断点管理
                        ui.group(|ui| {
                            ui.heading("断点管理");
                            ui.label("断点列表:");
                            ui.vertical(|ui| {
                                // 示例断点
                                ui.checkbox(&mut true, "kernel/main.chim:10");
                                ui.checkbox(&mut false, "kernel/io.chim:25");
                            });
                            if ui.button("添加断点").clicked() {
                                // 添加断点
                                self.output_log.push_str("添加新断点...\n");
                            }
                        });
                        
                        ui.separator();
                        
                        // 变量监控
                        ui.group(|ui| {
                            ui.heading("变量监控");
                            ui.label("当前变量:");
                            ui.vertical(|ui| {
                                // 示例变量
                                ui.label("counter: 42");
                                ui.label("current_task: Task { id: 1, name: 'init' }");
                                ui.label("memory_usage: 256 MB");
                            });
                            if ui.button("添加监控变量").clicked() {
                                // 添加变量监控
                                self.output_log.push_str("添加变量监控...\n");
                            }
                        });
                    });
                });
                
                egui::CentralPanel::default().show(ctx, |ui| {
                    ui.heading("系统实时预览");
                    
                    // 系统状态概览
                    ui.group(|ui| {
                        ui.heading("系统状态概览");
                        ui.horizontal(|ui| {
                            // CPU使用情况
                            ui.vertical(|ui| {
                                ui.label("CPU使用情况");
                                // 使用Slider模拟进度条
                                let mut value = 0.42;
                                ui.add(egui::Slider::new(&mut value, 0.0..=1.0).text("42%"));
                                for i in 0..4 {
                                    let mut core_value = 0.3 + i as f32 * 0.1;
                                    ui.add(egui::Slider::new(&mut core_value, 0.0..=1.0).text(format!("核心 {}: {:.0}%", i+1, (30 + i*10))));
                                }
                            });
                            
                            // 内存使用情况
                            ui.vertical(|ui| {
                                ui.label("内存使用情况");
                                let mut memory_value = 0.35;
                                ui.add(egui::Slider::new(&mut memory_value, 0.0..=1.0).text("35% (128 MB / 384 MB)"));
                            });
                        });
                    });
                    
                    ui.separator();
                    
                    // 实时日志输出
                    ui.group(|ui| {
                        ui.heading("实时日志");
                        egui::ScrollArea::vertical().show(ui, |ui| {
                            ui.monospace(&self.output_log);
                        });
                    });
                });
            },
        }

        // 如果正在构建或运行，持续更新界面
        if self.is_building || self.is_running {
            ctx.request_repaint();
        }
    }
}

impl OsDesignStudio {
    // 保存配置文件
    fn save_config(&mut self) {
        let config_path = Path::new(&self.chym_path).join("内核配置.json");
        let entry_path = Path::new(&self.chym_path).join("内核入口.chim");
        
        // 保存配置到JSON文件
        if let Err(e) = self.config.save_to_json(&config_path) {
            error!("无法保存配置文件: {:?}", e);
            self.output_log.push_str(&format!("错误: 无法保存配置文件: {:?}\n", e));
        } else {
            info!("配置文件已保存到: {:?}", config_path);
            self.output_log.push_str(&format!("配置文件已保存到: {:?}\n", config_path));
        }
        
        // 生成内核入口文件
        if let Err(e) = self.config.generate_kernel_entry(&entry_path) {
            error!("无法生成内核入口文件: {:?}", e);
            self.output_log.push_str(&format!("错误: 无法生成内核入口文件: {:?}\n", e));
        } else {
            info!("内核入口文件已生成到: {:?}", entry_path);
            self.output_log.push_str(&format!("内核入口文件已生成到: {:?}\n", entry_path));
        }
    }
    
    // 构建内核
    async fn build_kernel(mut self) {
        // 检查Chym环境
        let env_result = check_chym_environment(&self.chym_path);
        self.output_log.push_str(&env_result.output);
        
        if env_result.success {
            // 执行构建
            let result = build_chym(&self.chym_path).await;
            self.output_log.push_str(&result.output);
        }
        
        self.is_building = false;
    }
    
    // 运行内核
    async fn run_kernel(mut self) {
        // 检查Chym环境
        let env_result = check_chym_environment(&self.chym_path);
        self.output_log.push_str(&env_result.output);
        
        if env_result.success {
            // 执行运行
            let result = run_chym(&self.chym_path).await;
            self.output_log.push_str(&result.output);
        }
        
        self.is_running = false;
    }
}

fn main() {
    // 初始化日志系统
    env_logger::init();
    
    info!("启动OS Design Studio...");
    
    // 配置egui选项
    let options = eframe::NativeOptions {
        viewport: egui::ViewportBuilder::default()
            .with_inner_size([1000.0, 700.0])
            .with_resizable(true),
        ..Default::default()
    };
    
    // 运行应用程序
    eframe::run_native(
        "OS Design Studio",
        options,
        Box::new(|_cc| Ok(Box::<OsDesignStudio>::default())),
    ).unwrap();
}
